﻿using jiuyuan.数据.共享类;
using jiuyuan.数据.基础数据类;
using jiuyuan.数据.怪物类;
using jiuyuan.数据.玩家类;
using jiuyuan.服务;
using Microsoft.Extensions.Logging;

namespace jiuyuan.管理器;

// 怪物AI管理器
public class 怪物AI管理器(ILogger<怪物AI管理器> 日志器)
{
    private readonly ILogger<怪物AI管理器> _日志器 = 日志器;

    /// <summary>
    /// 生成玩家决策
    /// </summary>
    public AI决策 生成玩家决策(玩家 玩家, List<怪物> 怪物队伍)
    {
        // 简单的AI逻辑：优先攻击血量最多的怪物
        var 活着的怪物 = 怪物队伍.Where(m => m.是否存活).ToList();
        if (活着的怪物.Count != 0)
        {
            var 目标怪物 = 活着的怪物.OrderByDescending(m => m.当前生命值).First();
            return new AI决策("攻击", null, 目标怪物);
        }

        // 如果没有怪物，使用技能
        if (玩家.当前技能槽.Count != 0)
        {
            var 技能 = 玩家.当前技能槽.First();
            var 目标列表 = 活着的怪物.Cast<战斗单位>().ToList();
            if (目标列表.Count != 0)
            {
                return new AI决策("技能", 技能.名称, 目标列表.First())
                {
                    目标列表 = 目标列表
                };
            }
        }

        // 默认攻击第一个怪物
        return new AI决策("攻击");
    }

    /// <summary>
    /// 生成怪物决策
    /// </summary>
    public AI决策 生成怪物决策(怪物 怪物, List<玩家> 玩家队伍)
    {
        // 简单的AI逻辑：优先攻击血量最少的玩家
        var 活着的玩家 = 玩家队伍.Where(p => p.是否存活).ToList();
        if (活着的玩家.Any())
        {
            var 目标玩家 = 活着的玩家.OrderBy(p => p.当前生命值).First();
            return new AI决策("攻击", null, 目标玩家);
        }

        // 默认攻击第一个玩家
        return new AI决策("攻击");
    }

    /// <summary>
    /// 生成智能决策
    /// </summary>
    public AI决策 生成智能决策(战斗单位 单位, 战斗上下文 战斗上下文)
    {
        // 获取敌方和友方单位
        var 敌方单位 = 战斗上下文.获取敌方单位(单位);
        var 友方单位 = 战斗上下文.获取友方单位(单位);
        
        var 活着的敌方 = 敌方单位.Where(u => u.是否存活).ToList();
        
        if (!活着的敌方.Any())
        {
            return new AI决策("攻击"); // 默认决策
        }

        // 如果是玩家
        if (单位 is 玩家 玩家单位)
        {
            // 检查是否有可用技能
            if (玩家单位.当前技能槽.Any() && 玩家单位.当前魔法值 > 0)
            {
                // 选择一个技能使用
                var 技能 = 玩家单位.当前技能槽.FirstOrDefault();
                if (技能 != null)
                {
                    return new AI决策("技能", 技能.名称, 活着的敌方.First())
                    {
                        目标列表 = 活着的敌方
                    };
                }
            }
            
            // 默认攻击血量最多的敌人
            var 目标 = 活着的敌方.OrderByDescending(e => e.当前生命值).First();
            return new AI决策("攻击", null, 目标);
        }
        // 如果是怪物
        else if (单位 is 怪物 怪物单位)
        {
            // 检查是否有技能
            if (怪物单位.技能列表.Any() && 怪物单位.当前魔法值 > 0)
            {
                // 选择一个技能使用
                var 技能 = 怪物单位.技能列表.FirstOrDefault();
                if (技能 != null)
                {
                    return new AI决策("技能", 技能.名称, 活着的敌方.First())
                    {
                        目标列表 = 活着的敌方
                    };
                }
            }
            
            // 默认攻击血量最少的敌人
            var 目标 = 活着的敌方.OrderBy(e => e.当前生命值).First();
            return new AI决策("攻击", null, 目标);
        }

        // 默认决策
        return new AI决策("攻击");
    }
}